package com.lz.autotest.project.testmanage.envmanage.service.impl;

import com.lz.autotest.common.constant.CacheConst;
import com.lz.autotest.common.constant.CacheConstants;
import com.lz.autotest.common.constant.UserConstants;
import com.lz.autotest.common.entity.ResponseVo;
import com.lz.autotest.common.redis.RedisCache;
import com.lz.autotest.common.text.Convert;
import com.lz.autotest.common.utils.SecurityUtils;
import com.lz.autotest.common.utils.StringUtils;
import com.lz.autotest.project.testmanage.envmanage.domain.TsstEnv;
import com.lz.autotest.project.testmanage.envmanage.mapper.TsstEnvMapper;
import com.lz.autotest.project.testmanage.envmanage.service.TsstEnvService;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.List;

/**
 * @author: X
 * @date: Created in 2023/7/31 11:24
 * @Description:
 */
@Service
public class TsstEnvServiceImpl implements TsstEnvService {

    @Resource
    private TsstEnvMapper tsstEnvMapper;

    @Resource
    private RedisCache redisCache;

    /**
     * 项目启动时，初始化环境到缓存
     */
    @PostConstruct
    public void init() {
        loadingEnvCache();
    }

    /**
     * @desc 加载环境缓存数据
     * @author X
     * @date 2023/7/31 16:08
     **/
    public void loadingEnvCache() {
        List<TsstEnv> tsstEnvs = tsstEnvMapper.selectTsstEnvList(new TsstEnv());
        for (TsstEnv tsstEnv : tsstEnvs) {
            redisCache.setCacheObject(getCacheKey(tsstEnv.getEnvId()), tsstEnv.getAddress());
        }
    }

    /**
     * @desc 新增环境
     * @author X
     * @date 2023/7/31 16:08
     **/
    @Override
    public int insert(TsstEnv tsstEnv) {
        tsstEnv.setCreateBy(SecurityUtils.getUsername());
        int row = tsstEnvMapper.insert(tsstEnv);
        if (row > 0) {
            redisCache.setCacheObject(getCacheKey(tsstEnv.getEnvId()), tsstEnv.getAddress());
        }
        return row;
    }

    /**
     * @desc 删除环境
     * @author X
     * @date 2023/7/31 16:08
     **/
    @Override
    public void delete(Long[] ids) {
        for (Long id : ids) {
            TsstEnv queryEnv = new TsstEnv();
            queryEnv.setEnvId(id);
            TsstEnv tsstEnv = tsstEnvMapper.selectTsstEnv(queryEnv);
            tsstEnvMapper.deleteTsstEnvById(id);
            redisCache.deleteObject(getCacheKey(tsstEnv.getEnvId()));
        }
    }

    /**
     * @desc 更新环境
     * @author X
     * @date 2023/7/31 16:08
     **/
    @Override
    public int update(TsstEnv tsstEnv) {
        int row = tsstEnvMapper.update(tsstEnv);
        if (row > 0) {
            redisCache.setCacheObject(getCacheKey(tsstEnv.getEnvId()), tsstEnv.getAddress());
        }
        return row;
    }

    /**
     * @desc 根据条件查询环境列表
     * @author X
     * @date 2023/7/31 16:08
     **/
    @Override
    public List<TsstEnv> selectTsstEnvList(TsstEnv tsstEnv) {
        return tsstEnvMapper.selectTsstEnvList(tsstEnv);
    }

    /**
     * @desc 设置默认环境
     * @author X
     * @date 2023/7/31 16:07
     **/
    @Override
    public void updateDefault(Long id) {
        tsstEnvMapper.updateSetDefault(id);
        tsstEnvMapper.updateSetNoDefault(id);
    }

    /**
     * @desc 获取默认的环境
     * @author X
     * @date 2023/7/31 16:08
     **/
    @Override
    public TsstEnv selectDefaultEnv() {
        return tsstEnvMapper.selectDefaultEnv();
    }

    /**
     * @desc 检查环境唯一
     * @author X
     * @date 2023/7/31 16:08
     **/
    @Override
    public ResponseVo checkEnvUnique(TsstEnv tsstEnv) {
        if (UserConstants.NOT_UNIQUE.equals(checkEnvNameUnique(tsstEnv))) {
            return ResponseVo.failure("新增环境失败'" + tsstEnv.getEnvName() + "'环境名称已存在");
        }
        return ResponseVo.success();
    }

    /**
     * @desc 根据ID查询环境信息
     * @author X
     * @date 2023/7/31 16:08
     **/
    @Override
    public String selectTsstEnvByEnvId(Long envId) {
        String value = Convert.toStr(redisCache.getCacheObject(getCacheKey(envId)));
        if (StringUtils.isNotEmpty(value)) {
            return value;
        }
        TsstEnv tsstEnv = new TsstEnv();
        TsstEnv envByKey = tsstEnvMapper.selectTsstEnv(tsstEnv);
        if (StringUtils.isNotNull(envByKey)) {
            redisCache.setCacheObject(getCacheKey(envId), envByKey.getAddress());
            return envByKey.getAddress();
        }
        return StringUtils.EMPTY;
    }

    /**
     * @desc 根据ID查询环境信息
     * @author X
     * @date 2023/7/31 16:08
     **/
    @Override
    public TsstEnv selectTsstEnv(TsstEnv tsstEnv) {
        return tsstEnvMapper.selectTsstEnv(tsstEnv);
    }

    public String checkEnvKeyUnique(TsstEnv tsstEnv) {
        long configId = StringUtils.isNull(tsstEnv.getEnvId()) ? -1L : tsstEnv.getEnvId();
        TsstEnv info = tsstEnvMapper.checkEnvKeyUnique(tsstEnv.getEnvName());
        if (StringUtils.isNotNull(info) && info.getEnvId() != configId) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * @desc 检查环境名称是否唯一
     * @author X
     * @date 2023/7/31 16:08
     **/
    public String checkEnvNameUnique(TsstEnv tsstEnv) {
        Long configId = StringUtils.isNull(tsstEnv.getEnvId()) ? -1L : tsstEnv.getEnvId();
        TsstEnv info = tsstEnvMapper.checkEnvNameUnique(tsstEnv.getEnvName());
        if (StringUtils.isNotNull(info) && info.getEnvId().longValue() != configId.longValue()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 设置cache key
     *
     * @param envId 参数键
     * @return 缓存键key
     */
    private String getCacheKey(Long envId) {
        return CacheConst.env + CacheConstants.ENV + envId;
    }
}
